Termination of the given ITRSProblem could successfully be proven:



↳ ITRS
  ↳ ITRStoIDPProof

ITRS problem:
The following domains are used:

z

The TRS R consists of the following rules:

Cond_rand2(TRUE, x, y) → y
rand(x, y) → Cond_rand(>@z(0@z, x), x, y)
random(x) → rand(x, 0@z)
Cond_rand1(TRUE, x, y) → rand(+@z(-@z(x), 1@z), id_inc(y))
rand(x, y) → Cond_rand1(>@z(x, 0@z), x, y)
id_dec(x) → x
id_inc(x) → x
Cond_rand(TRUE, x, y) → rand(-@z(-@z(x), 1@z), id_dec(y))
id_inc(x) → +@z(x, 1@z)
rand(x, y) → Cond_rand2(=@z(x, 0@z), x, y)
id_dec(x) → -@z(x, 1@z)

The set Q consists of the following terms:

Cond_rand2(TRUE, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(TRUE, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(TRUE, x0, x1)


Added dependency pairs

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

Cond_rand2(TRUE, x, y) → y
rand(x, y) → Cond_rand(>@z(0@z, x), x, y)
random(x) → rand(x, 0@z)
Cond_rand1(TRUE, x, y) → rand(+@z(-@z(x), 1@z), id_inc(y))
rand(x, y) → Cond_rand1(>@z(x, 0@z), x, y)
id_dec(x) → x
id_inc(x) → x
Cond_rand(TRUE, x, y) → rand(-@z(-@z(x), 1@z), id_dec(y))
id_inc(x) → +@z(x, 1@z)
rand(x, y) → Cond_rand2(=@z(x, 0@z), x, y)
id_dec(x) → -@z(x, 1@z)

The integer pair graph contains the following rules and edges:

(0): COND_RAND1(TRUE, x[0], y[0]) → ID_INC(y[0])
(1): COND_RAND(TRUE, x[1], y[1]) → RAND(-@z(-@z(x[1]), 1@z), id_dec(y[1]))
(2): RAND(x[2], y[2]) → COND_RAND(>@z(0@z, x[2]), x[2], y[2])
(3): RAND(x[3], y[3]) → COND_RAND1(>@z(x[3], 0@z), x[3], y[3])
(4): RAND(x[4], y[4]) → COND_RAND2(=@z(x[4], 0@z), x[4], y[4])
(5): COND_RAND(TRUE, x[5], y[5]) → ID_DEC(y[5])
(6): COND_RAND1(TRUE, x[6], y[6]) → RAND(+@z(-@z(x[6]), 1@z), id_inc(y[6]))
(7): RANDOM(x[7]) → RAND(x[7], 0@z)

(1) -> (2), if ((id_dec(y[1]) →* y[2])∧(-@z(-@z(x[1]), 1@z) →* x[2]))


(1) -> (3), if ((id_dec(y[1]) →* y[3])∧(-@z(-@z(x[1]), 1@z) →* x[3]))


(1) -> (4), if ((id_dec(y[1]) →* y[4])∧(-@z(-@z(x[1]), 1@z) →* x[4]))


(2) -> (1), if ((x[2] →* x[1])∧(y[2] →* y[1])∧(>@z(0@z, x[2]) →* TRUE))


(2) -> (5), if ((x[2] →* x[5])∧(y[2] →* y[5])∧(>@z(0@z, x[2]) →* TRUE))


(3) -> (0), if ((x[3] →* x[0])∧(y[3] →* y[0])∧(>@z(x[3], 0@z) →* TRUE))


(3) -> (6), if ((x[3] →* x[6])∧(y[3] →* y[6])∧(>@z(x[3], 0@z) →* TRUE))


(6) -> (2), if ((id_inc(y[6]) →* y[2])∧(+@z(-@z(x[6]), 1@z) →* x[2]))


(6) -> (3), if ((id_inc(y[6]) →* y[3])∧(+@z(-@z(x[6]), 1@z) →* x[3]))


(6) -> (4), if ((id_inc(y[6]) →* y[4])∧(+@z(-@z(x[6]), 1@z) →* x[4]))


(7) -> (2), if ((x[7] →* x[2]))


(7) -> (3), if ((x[7] →* x[3]))


(7) -> (4), if ((x[7] →* x[4]))



The set Q consists of the following terms:

Cond_rand2(TRUE, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(TRUE, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(TRUE, x0, x1)


As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

id_dec(x) → x
id_inc(x) → x
id_inc(x) → +@z(x, 1@z)
id_dec(x) → -@z(x, 1@z)

The integer pair graph contains the following rules and edges:

(0): COND_RAND1(TRUE, x[0], y[0]) → ID_INC(y[0])
(1): COND_RAND(TRUE, x[1], y[1]) → RAND(-@z(-@z(x[1]), 1@z), id_dec(y[1]))
(2): RAND(x[2], y[2]) → COND_RAND(>@z(0@z, x[2]), x[2], y[2])
(3): RAND(x[3], y[3]) → COND_RAND1(>@z(x[3], 0@z), x[3], y[3])
(4): RAND(x[4], y[4]) → COND_RAND2(=@z(x[4], 0@z), x[4], y[4])
(5): COND_RAND(TRUE, x[5], y[5]) → ID_DEC(y[5])
(6): COND_RAND1(TRUE, x[6], y[6]) → RAND(+@z(-@z(x[6]), 1@z), id_inc(y[6]))
(7): RANDOM(x[7]) → RAND(x[7], 0@z)

(1) -> (2), if ((id_dec(y[1]) →* y[2])∧(-@z(-@z(x[1]), 1@z) →* x[2]))


(1) -> (3), if ((id_dec(y[1]) →* y[3])∧(-@z(-@z(x[1]), 1@z) →* x[3]))


(1) -> (4), if ((id_dec(y[1]) →* y[4])∧(-@z(-@z(x[1]), 1@z) →* x[4]))


(2) -> (1), if ((x[2] →* x[1])∧(y[2] →* y[1])∧(>@z(0@z, x[2]) →* TRUE))


(2) -> (5), if ((x[2] →* x[5])∧(y[2] →* y[5])∧(>@z(0@z, x[2]) →* TRUE))


(3) -> (0), if ((x[3] →* x[0])∧(y[3] →* y[0])∧(>@z(x[3], 0@z) →* TRUE))


(3) -> (6), if ((x[3] →* x[6])∧(y[3] →* y[6])∧(>@z(x[3], 0@z) →* TRUE))


(6) -> (2), if ((id_inc(y[6]) →* y[2])∧(+@z(-@z(x[6]), 1@z) →* x[2]))


(6) -> (3), if ((id_inc(y[6]) →* y[3])∧(+@z(-@z(x[6]), 1@z) →* x[3]))


(6) -> (4), if ((id_inc(y[6]) →* y[4])∧(+@z(-@z(x[6]), 1@z) →* x[4]))


(7) -> (2), if ((x[7] →* x[2]))


(7) -> (3), if ((x[7] →* x[3]))


(7) -> (4), if ((x[7] →* x[4]))



The set Q consists of the following terms:

Cond_rand2(TRUE, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(TRUE, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(TRUE, x0, x1)


The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof

I DP problem:
The following domains are used:

z

The ITRS R consists of the following rules:

id_dec(x) → x
id_inc(x) → x
id_inc(x) → +@z(x, 1@z)
id_dec(x) → -@z(x, 1@z)

The integer pair graph contains the following rules and edges:

(1): COND_RAND(TRUE, x[1], y[1]) → RAND(-@z(-@z(x[1]), 1@z), id_dec(y[1]))
(2): RAND(x[2], y[2]) → COND_RAND(>@z(0@z, x[2]), x[2], y[2])
(3): RAND(x[3], y[3]) → COND_RAND1(>@z(x[3], 0@z), x[3], y[3])
(6): COND_RAND1(TRUE, x[6], y[6]) → RAND(+@z(-@z(x[6]), 1@z), id_inc(y[6]))

(2) -> (1), if ((x[2] →* x[1])∧(y[2] →* y[1])∧(>@z(0@z, x[2]) →* TRUE))


(3) -> (6), if ((x[3] →* x[6])∧(y[3] →* y[6])∧(>@z(x[3], 0@z) →* TRUE))


(1) -> (3), if ((id_dec(y[1]) →* y[3])∧(-@z(-@z(x[1]), 1@z) →* x[3]))


(1) -> (2), if ((id_dec(y[1]) →* y[2])∧(-@z(-@z(x[1]), 1@z) →* x[2]))


(6) -> (3), if ((id_inc(y[6]) →* y[3])∧(+@z(-@z(x[6]), 1@z) →* x[3]))


(6) -> (2), if ((id_inc(y[6]) →* y[2])∧(+@z(-@z(x[6]), 1@z) →* x[2]))



The set Q consists of the following terms:

Cond_rand2(TRUE, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(TRUE, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(TRUE, x0, x1)


Represented integers and predefined function symbols by Terms

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(x[2], y[2]) → COND_RAND(greater_int(pos(0), x[2]), x[2], y[2])
RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

id_dec(x) → x
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
id_dec(x) → minus_int(x, pos(s(0)))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(neg(x), pos(y)) → minus_nat(y, x)
plus_int(neg(x), neg(y)) → neg(plus_nat(x, y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), neg(y)) → minus_nat(y, x)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
minus_int(pos(x), neg(y)) → pos(plus_nat(x, y))
neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))

The set Q consists of the following terms:

Cond_rand2(true, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(true, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(true, x0, x1)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(x[2], y[2]) → COND_RAND(greater_int(pos(0), x[2]), x[2], y[2])
RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)

The set Q consists of the following terms:

Cond_rand2(true, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(true, x0, x1)
id_dec(x0)
id_inc(x0)
Cond_rand(true, x0, x1)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

Cond_rand2(true, x0, x1)
rand(x0, x1)
random(x0)
Cond_rand1(true, x0, x1)
Cond_rand(true, x0, x1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(x[2], y[2]) → COND_RAND(greater_int(pos(0), x[2]), x[2], y[2])
RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule RAND(x[2], y[2]) → COND_RAND(greater_int(pos(0), x[2]), x[2], y[2]) at position [0] we obtained the following new rules [LPAR04]:

RAND(pos(0), y1) → COND_RAND(false, pos(0), y1)
RAND(pos(s(x0)), y1) → COND_RAND(false, pos(s(x0)), y1)
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(neg(0), y1) → COND_RAND(false, neg(0), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
RAND(pos(0), y1) → COND_RAND(false, pos(0), y1)
RAND(pos(s(x0)), y1) → COND_RAND(false, pos(s(x0)), y1)
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(neg(0), y1) → COND_RAND(false, neg(0), y1)

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3])
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule RAND(x[3], y[3]) → COND_RAND1(greater_int(x[3], pos(0)), x[3], y[3]) at position [0] we obtained the following new rules [LPAR04]:

RAND(neg(s(x0)), y1) → COND_RAND1(false, neg(s(x0)), y1)
RAND(pos(0), y1) → COND_RAND1(false, pos(0), y1)
RAND(neg(0), y1) → COND_RAND1(false, neg(0), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(neg(s(x0)), y1) → COND_RAND1(false, neg(s(x0)), y1)
RAND(pos(0), y1) → COND_RAND1(false, pos(0), y1)
RAND(neg(0), y1) → COND_RAND1(false, neg(0), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 3 less nodes.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
greater_int(pos(0), pos(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1]))
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_RAND(true, x[1], y[1]) → RAND(minus_int(neg_int(x[1]), pos(s(0))), id_dec(y[1])) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND(true, pos(x0), y1) → RAND(minus_int(neg(x0), pos(s(0))), id_dec(y1))
COND_RAND(true, neg(x0), y1) → RAND(minus_int(pos(x0), pos(s(0))), id_dec(y1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
COND_RAND(true, pos(x0), y1) → RAND(minus_int(neg(x0), pos(s(0))), id_dec(y1))
COND_RAND(true, neg(x0), y1) → RAND(minus_int(pos(x0), pos(s(0))), id_dec(y1))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, neg(x0), y1) → RAND(minus_int(pos(x0), pos(s(0))), id_dec(y1))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND(true, neg(x0), y1) → RAND(minus_int(pos(x0), pos(s(0))), id_dec(y1)) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6]))
COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_RAND1(true, x[6], y[6]) → RAND(plus_int(pos(s(0)), neg_int(x[6])), id_inc(y[6])) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1))
COND_RAND1(true, neg(x0), y1) → RAND(plus_int(pos(s(0)), pos(x0)), id_inc(y1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))
COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1))
COND_RAND1(true, neg(x0), y1) → RAND(plus_int(pos(s(0)), pos(x0)), id_inc(y1))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1))

The TRS R consists of the following rules:

neg_int(pos(x)) → neg(x)
neg_int(neg(x)) → pos(x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1))

The TRS R consists of the following rules:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))
neg_int(pos(x0))
neg_int(neg(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

neg_int(pos(x0))
neg_int(neg(x0))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1))

The TRS R consists of the following rules:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND1(true, pos(x0), y1) → RAND(plus_int(pos(s(0)), neg(x0)), id_inc(y1)) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1))
RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1))

The TRS R consists of the following rules:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_RAND(true, neg(x0), y1) → RAND(minus_nat(x0, s(0)), id_dec(y1)) at position [1] we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)

The TRS R consists of the following rules:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
id_dec(x) → x
id_dec(x) → minus_int(x, pos(s(0)))
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)

The TRS R consists of the following rules:

minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))

The set Q consists of the following terms:

id_dec(x0)
id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

id_dec(x0)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)

The TRS R consists of the following rules:

minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))

The set Q consists of the following terms:

id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND_RAND1(true, pos(x0), y1) → RAND(minus_nat(s(0), x0), id_inc(y1)) at position [1] we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))

The TRS R consists of the following rules:

minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(s(x), 0) → pos(s(x))
id_inc(x) → x
id_inc(x) → plus_int(pos(s(0)), x)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))

The set Q consists of the following terms:

id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

id_inc(x0)
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].

id_inc(x0)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0))))
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), minus_int(x0, pos(s(0)))) we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), minus_int(z1, pos(s(0))))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), minus_int(z1, pos(s(0))))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), minus_int(z1, pos(s(0)))) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_RAND(true, neg(y0), x0) → RAND(minus_nat(y0, s(0)), x0) we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), z1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), z1)

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(s(z0), s(0)), z1) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), x0) we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), z1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), z1)

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), z1) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), z1)



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ Instantiation

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), z1)

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND_RAND1(true, pos(y0), x0) → RAND(minus_nat(s(0), y0), plus_int(pos(s(0)), x0)) we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), plus_int(pos(s(0)), z1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ Instantiation
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), plus_int(pos(s(0)), z1))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(s(0), s(z0)), plus_int(pos(s(0)), z1)) at position [0] we obtained the following new rules [LPAR04]:

COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), plus_int(pos(s(0)), z1))



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ Instantiation
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Rewriting
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ MRRProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), plus_int(pos(s(0)), z1))

The TRS R consists of the following rules:

minus_nat(s(x), s(y)) → minus_nat(x, y)
minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), z1)
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), z1)

Strictly oriented rules of the TRS R:

minus_nat(s(x), s(y)) → minus_nat(x, y)

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(COND_RAND(x1, x2, x3)) = x1 + x2 + x3   
POL(COND_RAND1(x1, x2, x3)) = x1 + x2 + x3   
POL(RAND(x1, x2)) = x1 + x2   
POL(minus_int(x1, x2)) = x1 + x2   
POL(minus_nat(x1, x2)) = x1 + x2   
POL(neg(x1)) = x1   
POL(plus_int(x1, x2)) = x1 + x2   
POL(plus_nat(x1, x2)) = x1 + x2   
POL(pos(x1)) = x1   
POL(s(x1)) = 1 + x1   
POL(true) = 0   



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ Instantiation
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Rewriting
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ MRRProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ MRRProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)
COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), plus_int(pos(s(0)), z1))

The TRS R consists of the following rules:

minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(pos(x), pos(y)) → minus_nat(x, y)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [LPAR04] with the following ordering, at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

COND_RAND(true, neg(s(z0)), z1) → RAND(minus_nat(z0, 0), minus_int(z1, pos(s(0))))
COND_RAND1(true, pos(s(z0)), z1) → RAND(minus_nat(0, z0), plus_int(pos(s(0)), z1))

Strictly oriented rules of the TRS R:

minus_nat(s(x), 0) → pos(s(x))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
minus_nat(0, s(y)) → neg(s(y))
minus_nat(0, 0) → pos(0)
minus_int(neg(x), pos(y)) → neg(plus_nat(x, y))

Used ordering: Polynomial interpretation [POLO]:

POL(0) = 0   
POL(COND_RAND(x1, x2, x3)) = 2·x1 + 2·x2 + x3   
POL(COND_RAND1(x1, x2, x3)) = x1 + 2·x2 + x3   
POL(RAND(x1, x2)) = 2·x1 + x2   
POL(minus_int(x1, x2)) = x1 + x2   
POL(minus_nat(x1, x2)) = 2 + 2·x1 + 2·x2   
POL(neg(x1)) = 1 + 2·x1   
POL(plus_int(x1, x2)) = x1 + x2   
POL(plus_nat(x1, x2)) = x1 + x2   
POL(pos(x1)) = 1 + 2·x1   
POL(s(x1)) = 2 + x1   
POL(true) = 0   



↳ ITRS
  ↳ ITRStoIDPProof
    ↳ IDP
      ↳ UsableRulesProof
        ↳ IDP
          ↳ IDependencyGraphProof
            ↳ IDP
              ↳ IDPtoQDPProof
                ↳ QDP
                  ↳ UsableRulesProof
                    ↳ QDP
                      ↳ QReductionProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ UsableRulesProof
                                    ↳ QDP
                                      ↳ Narrowing
                                        ↳ QDP
                                          ↳ DependencyGraphProof
                                            ↳ QDP
                                              ↳ UsableRulesProof
                                                ↳ QDP
                                                  ↳ QReductionProof
                                                    ↳ QDP
                                                      ↳ Narrowing
                                                        ↳ QDP
                                                          ↳ DependencyGraphProof
                                                            ↳ QDP
                                                              ↳ Rewriting
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ UsableRulesProof
                                                                            ↳ QDP
                                                                              ↳ QReductionProof
                                                                                ↳ QDP
                                                                                  ↳ Rewriting
                                                                                    ↳ QDP
                                                                                      ↳ Narrowing
                                                                                        ↳ QDP
                                                                                          ↳ UsableRulesProof
                                                                                            ↳ QDP
                                                                                              ↳ QReductionProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ UsableRulesProof
                                                                                                        ↳ QDP
                                                                                                          ↳ QReductionProof
                                                                                                            ↳ QDP
                                                                                                              ↳ Instantiation
                                                                                                                ↳ QDP
                                                                                                                  ↳ Rewriting
                                                                                                                    ↳ QDP
                                                                                                                      ↳ Instantiation
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Rewriting
                                                                                                                            ↳ QDP
                                                                                                                              ↳ Instantiation
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Rewriting
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ Instantiation
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Rewriting
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ MRRProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ MRRProof
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

RAND(neg(s(x0)), y1) → COND_RAND(true, neg(s(x0)), y1)
RAND(pos(s(x0)), y1) → COND_RAND1(true, pos(s(x0)), y1)

The TRS R consists of the following rules:

plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_int(pos(x), pos(y)) → minus_nat(x, y)

The set Q consists of the following terms:

plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
minus_int(pos(x0), pos(x1))
minus_int(neg(x0), neg(x1))
minus_int(neg(x0), pos(x1))
minus_int(pos(x0), neg(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.